#include "DelayDeviceSDK.h"
#include <QDebug>
#include <QString>
#include <QVariantList>

/**
 * @brief 构造函数
 * @param parent 父对象指针（默认nullptr）
 */
DelayDeviceSDK::DelayDeviceSDK(QObject *parent) : ControlModuleSDKInterface(parent) {
    qDebug() << "DelayDeviceSDK instance created";
}

/**
 * @brief 析构函数（自动关闭所有设备连接）
 */
DelayDeviceSDK::~DelayDeviceSDK() {
    closeAllDevices();
    qDebug() << "DelayDeviceSDK instance destroyed";
}

/**
 * @brief 获取SDK名称
 * @return 字符串"DelayDeviceSDK"
 */
QString DelayDeviceSDK::sdkName() const {
    return "DelayDeviceSDK";
}

/**
 * @brief 获取SDK版本号
 * @return 字符串"1.0.0"
 */
QString DelayDeviceSDK::SDKVersion() const {
    return "1.0.0";
}

/**
 * @brief 打开设备连接
 * @param params 连接参数，应为QString类型的设备IP地址
 * @return 连接成功返回true，IP无效或连接失败返回false
 */
bool DelayDeviceSDK::openDevice(const QVariant& params) {
    QString ip = params.toString();
    if (!DelayDevice::ipIsValid(ip)) {
        writeLog(QString("延时模块的IP:%1无效!").arg(ip),2,false);
        return false;
    }

    // 检查设备是否已经连接
    if (m_deviceMap.contains(ip)) {
        writeLog(QString("延时模块%1已连接!").arg(ip),1,false);
        return true;
    }

    // 创建新的设备实例并尝试连接
    DelayDevice* device = new DelayDevice(ip, this);
    if (!device->open()) {
        delete device;
        writeLog(QString("延时模块%1打开失败!").arg(ip),2,false);
        return false;
    }
    DelayDeviceSDKInfo* pDeviceInfo=new DelayDeviceSDKInfo{device,nullptr,nullptr};
    // 连接成功后存储设备实例
    m_deviceMap.insert(ip, pDeviceInfo);

    writeLog(QString("延时模块%1打开成功!").arg(ip),0,true);
    return true;
}

/**
 * @brief 关闭指定设备连接
 * @param params 设备标识参数，应为QString类型的设备IP地址
 */
void DelayDeviceSDK::closeDevice(const QVariant& params) {
    QString ip = params.toString();
    if (!DelayDevice::ipIsValid(ip))
    {
       writeLog(QString("延时模块的IP:%1无效!").arg(ip),2,false);
       return;
    }

    // 查找并关闭指定设备
    if (!m_deviceMap.contains(ip))
    {
       writeLog(QString("未找到打开的延时控制模块:%1!").arg(ip),2,false);
    }
    DelayDeviceSDKInfo* pDeviceInfo = m_deviceMap[ip];
    pDeviceInfo->pDevice->close();
    delete pDeviceInfo->pDevice;
    if(pDeviceInfo->pParametersDialog)
    {
        delete pDeviceInfo->pParametersDialog;
    }
    delete pDeviceInfo;
    m_deviceMap.remove(ip);
    writeLog(QString("关闭延时控制模块:%1成功!").arg(ip),0,true);
}

/**
 * @brief 关闭所有设备连接
 */
void DelayDeviceSDK::closeAllDevices() {
    foreach (DelayDeviceSDKInfo* pDeviceInfo, m_deviceMap.values()) {
        pDeviceInfo->pDevice->close();
        delete pDeviceInfo->pDevice;
        if(pDeviceInfo->pParametersDialog)
        {
            delete pDeviceInfo->pParametersDialog;
        }
        delete pDeviceInfo;
    }
    m_deviceMap.clear();
}

/**
 * @brief 搜索可用的延时设备
 * @param devices 输出参数，存储搜索到的设备列表
 * @return 搜索成功返回true，未找到设备返回false
 */
bool DelayDeviceSDK::searchDevices(QList<QVariant>& devices)
{
    //设备未提供检索方式直接返回空
    devices.append("192.168.0.100");
    return !devices.isEmpty();
}

/**
 * @brief 获取设备快速参数设置界面
 * @param deviceId 设备ID
 * @param parent 父窗口部件
 * @return 快速参数设置界面
 */
QWidget* DelayDeviceSDK::getQuickParametersWidget(const QVariant& deviceId, QWidget* parent) {
    QString deviceIdStr = deviceId.toString();
    if (deviceIdStr.isEmpty()) {
        qWarning() << "Invalid device ID parameter";
        return nullptr;
    }
    
    if (!m_deviceMap.contains(deviceIdStr)) {
        qWarning() << "Device not found for ID:" << deviceIdStr;
        return nullptr;
    }
    
    DelayDeviceSDKInfo* pDeviceInfo = m_deviceMap[deviceIdStr];
    if(pDeviceInfo->pParametersWidget==nullptr)
    {
        pDeviceInfo->pParametersWidget=new DelayQuickParametersSet(pDeviceInfo->pDevice,parent);
    }

    return pDeviceInfo->pParametersWidget;
}

/**
 * @brief 获取设备参数设置对话框
 * @param deviceId 设备ID
 * @param parent 父窗口部件
 * @return 参数设置对话框
 */
QDialog* DelayDeviceSDK::getParametersDialog(const QVariant& deviceId, QWidget* parent) {
    QString deviceIdStr = deviceId.toString();
    if (deviceIdStr.isEmpty()) {
        qWarning() << "Invalid device ID parameter";
        return nullptr;
    }
    
    if (!m_deviceMap.contains(deviceIdStr)) {
        qWarning() << "Device not found for ID:" << deviceIdStr;
        return nullptr;
    }
    
    DelayDeviceSDKInfo* pDeviceInfo = m_deviceMap[deviceIdStr];
    if(!pDeviceInfo->pParametersDialog)
    {
        pDeviceInfo->pParametersDialog=new DelayDeviceParamsSet(pDeviceInfo->pDevice,parent);
    }

    return pDeviceInfo->pParametersDialog;
}

/**
 * @brief 获取设备预设参数设置对话框
 * @param deviceId 设备ID
 * @param parent 父窗口部件
 * @return 预设参数设置对话框
 */
QDialog* DelayDeviceSDK::getPresetParametersDialog(QWidget* parent)
{
    Q_UNUSED(parent)
    // 这里可以返回设备的预设参数设置对话框
    // 目前返回nullptr，需要根据实际UI实现进行修改
    return nullptr;
}

/**
 * @brief 设置设备触发模式
 * @param deviceId 设备ID
 * @param triggerMode 触发模式（0：实时采集，1：内触发，2：单次外触发，3：连续外触发）
 * @return 设置成功返回true，失败返回false
 */
bool DelayDeviceSDK::setDeviceTriggerMode(const QVariant& deviceId, int triggerMode)
{
    QString deviceIdStr = deviceId.toString();
    if (deviceIdStr.isEmpty()||!m_deviceMap.contains(deviceIdStr)||triggerMode!=0||triggerMode!=1||triggerMode!=3)
    {
        return false;
    }

    DelayDeviceSDKInfo* pDeviceInfo = m_deviceMap[deviceIdStr];
    int mode=3;

    if(triggerMode==2)
    {
        mode=1;
    }
    else if(triggerMode==3)
    {
        mode=0;
    }
    // 调用设备的触发模式设置方法
    bool result = pDeviceInfo->pDevice->setTriggerMode(mode);
    
    // 结果提示
    if (result)
    {
        writeLog("延时模块触发模式设置成功!",0,true);
    }
    else
    {
        writeLog("延时模块触发模式设置失败!",2,false);
    }
    return result;
}

bool DelayDeviceSDK::setDeviceParameters(const QVariant& deviceId, const QVariantMap& params)
{
    // 将deviceId转换为QString
    QString deviceIdStr = deviceId.toString();
    
    // 检查设备是否存在
    if (deviceIdStr.isEmpty() || !m_deviceMap.contains(deviceIdStr)) {
        writeLog(QString("设备 %1 不存在").arg(deviceIdStr), 2, true);
        return false;
    }
    
    // 获取设备实例
    DelayDevice* device = m_deviceMap[deviceIdStr]->pDevice;
    
    if(!device->setParameters(params))
    {
        return false;
    }
    emit device->updateArgs(this);
    return true;
}

bool DelayDeviceSDK::getDeviceParameters(const QVariant& deviceId, QString& configName, QVariantMap& params)
{
    // 将deviceId转换为QString
    QString deviceIdStr = deviceId.toString();
    
    // 检查设备是否存在
    if (deviceIdStr.isEmpty() || !m_deviceMap.contains(deviceIdStr)) {
        writeLog(QString("设备 %1 不存在").arg(deviceIdStr), 2, true);
        return false;
    }
    
    // 设置配置名称
    configName = "DelayDeviceConfig";
    
    // 获取设备实例
    DelayDevice* device = m_deviceMap[deviceIdStr]->pDevice;
    
    params = device->getParameters();
    return true;
}

bool DelayDeviceSDK::setPresetParameters(const QVariantMap& params)
{
    Q_UNUSED(params)
    return true;
}

bool DelayDeviceSDK::getPresetParameters(QString& configName, QVariantMap& params)
{
    // 设置配置名称
    configName.clear();
    
    // 清空参数
    params.clear();
    
    return true;
}
